/**
 * 检查值是否为对象
 * @param item 要检查的值
 * @returns 如果是对象则返回true，否则返回false
 */
export function isObject(item: unknown): item is Record<string, any> {
  return item !== null && typeof item === 'object' && !Array.isArray(item);
}

/**
 * 深度克隆一个值（对象、数组或基本类型）
 *
 * @param value 要克隆的值
 * @returns 克隆后的新值
 *
 * @example
 * ```ts
 * const originalObj = {
 *   theme: { color: 'blue', size: 'medium' },
 *   items: [1, 2, 3],
 *   enabled: true
 * };
 *
 * const clonedObj = deepClone(originalObj);
 * // clonedObj 是 originalObj 的深度副本
 * // 修改 clonedObj 不会影响 originalObj
 * ```
 */
export function deepClone<T>(value: T): T {
  // 处理基本类型和 null/undefined
  if (value === null || value === undefined || typeof value !== 'object') {
    return value;
  }

  // 处理日期对象
  if (value instanceof Date) {
    return new Date(value.getTime()) as unknown as T;
  }

  // 处理数组
  if (Array.isArray(value)) {
    return value.map(item => deepClone(item)) as unknown as T;
  }

  // 处理普通对象
  if (isObject(value)) {
    const result: Record<string, any> = {};

    for (const key in value) {
      if (Object.prototype.hasOwnProperty.call(value, key)) {
        result[key] = deepClone(value[key]);
      }
    }

    return result as T;
  }

  // 对于其他类型（如Map, Set等），返回浅拷贝
  // 注意：这是简化实现，实际应用中可能需要处理更多复杂类型
  return value;
}

/**
 * 浅克隆对象
 *
 * @param obj 要克隆的对象
 * @returns 浅克隆后的新对象
 *
 * @example
 * ```ts
 * const original = { name: 'John', settings: { theme: 'dark' } };
 * const cloned = shallowClone(original);
 * // 修改 cloned.name 不会影响 original.name
 * // 但修改 cloned.settings.theme 会影响 original.settings.theme
 * ```
 */
export function shallowClone<T>(obj: T): T {
  if (Array.isArray(obj)) {
    return [...obj] as unknown as T;
  }

  if (isObject(obj)) {
    return {...obj};
  }

  return obj;
}
